
(function(window,document,Laya){
	var __un=Laya.un,__uns=Laya.uns,__static=Laya.static,__class=Laya.class,__getset=Laya.getset,__newvec=Laya.__newvec;

	var Box=laya.editorUI.Box,Browser=laya.utils.Browser,Component=laya.editorUI.Component,Event=laya.events.Event;
	var Handler=laya.utils.Handler,Loader=laya.editorUI.Loader,Point=laya.maths.Point,Sprite=laya.display.Sprite;
//class laya.maker.plugin.rocker.RockerSprite extends laya.display.Sprite
var RockerSprite=(function(_super){
	function RockerSprite(rocker){
		this._rocker=null;
		RockerSprite.__super.call(this);
		this._rocker=rocker;
	}

	__class(RockerSprite,'laya.maker.plugin.rocker.RockerSprite',_super);
	var __proto=RockerSprite.prototype;
	/**@inheritDoc */
	__proto.pos=function(x,y,speedMode){
		(speedMode===void 0)&& (speedMode=false);
		_super.prototype.pos.call(this,x,y,speedMode);
		this._rocker.updateFixedTouchArea();
		return this;
	}

	/**@inheritDoc */
	__proto.scale=function(scaleX,scaleY,speedMode){
		(speedMode===void 0)&& (speedMode=false);
		_super.prototype.scale.call(this,scaleX,scaleY,speedMode);
		this._rocker.updateFixedTouchArea();
		return this;
	}

	/**@inheritDoc */
	__getset(0,__proto,'x',_super.prototype._$get_x,function(value){
		Laya.superSet(Sprite,this,'x',value);
		this._rocker.updateFixedTouchArea();
	});

	/**@inheritDoc */
	__getset(0,__proto,'y',_super.prototype._$get_y,function(value){
		Laya.superSet(Sprite,this,'y',value);
		this._rocker.updateFixedTouchArea();
	});

	/**@inheritDoc */
	__getset(0,__proto,'scaleX',_super.prototype._$get_scaleX,function(value){
		Laya.superSet(Sprite,this,'scaleX',value);
		this._rocker.updateFixedTouchArea();
	});

	/**@inheritDoc */
	__getset(0,__proto,'transform',_super.prototype._$get_transform,function(value){
		Laya.superSet(Sprite,this,'transform',value);
		this._rocker.updateFixedTouchArea();
	});

	/**@inheritDoc */
	__getset(0,__proto,'scaleY',_super.prototype._$get_scaleY,function(value){
		Laya.superSet(Sprite,this,'scaleY',value);
		this._rocker.updateFixedTouchArea();
	});

	return RockerSprite;
})(Sprite)


/**
*摇杆组件。<br/>
*使用示例：<br/>
*var hero:Hero=new Hero();<br/>
*var rockerContain:Sprite=Laya.stage.addChild(new Sprite())as Sprite;<br/>
*var rocker:Rocker=rockerContain.addChild(new Rocker(false,false))as Rocker;<br/>
*rocker.pos(rocker.rockRadius+50,Laya.stage.height-rocker.rockRadius-50);<br/>
*rocker.setSkin(_bgSkin,_knobSkin);<br/>
*rocker.on(Event.LOADED,this,onLoaded);<br/>
*rocker.reg(hero);<br/>
*<br/>
*function onLoaded(url:String,texWidth:Number,texHeight:Number):void {<br/>
	*if (url===_bgSkin){<br/>
		*rocker.setRockArea(texWidth / 2);<br/>
		*rocker.setTouchArea(texWidth,texHeight);<br/>
		*}<br/>
	*}
*/
//class laya.maker.plugin.rocker.Rocker extends laya.editorUI.Component
var Rocker=(function(_super){
	function Rocker(){
		/**
		*Rocker的显示节点
		*/
		this.rockerNode=null;
		/**
		*触控进行有效移动的最小偏移量(X轴或Y轴任一轴向上的偏移量)，单位为像素，只在摇杆进入移动激活状态时有效。
		*/
		this.mouseMoveAccuracy=2;
		/**
		*摇杆移动激活半径，单位为像素，默认值为8。<br/>
		*此半径以摇杆中心点为圆心，定义了一个圆形区域，当玩家触控开始，且触控点一直在此区域内移动时，摇杆处于TouchDown状态，当触控点超出此区域后，摇杆更新状态为TouchMove，之后触控点再次返回区域内部时，摇杆状态依然为TouchMove。
		*/
		this.activeRadius=8;
		/**
		*摇动区域半径，单位为像素，默认值为100。
		*/
		this.rockRadius=100;
		/**
		*将单位圆按指定角度进行均匀分段，开发者可以指定每段的角度阈值，默认值为5，也就是分为72段。<br/>
		*常用于优化与服务器同步对象状态的通讯频率。<br/>
		*如果为5，则将单位圆等分为72段，(-2.5,2.5)区间范围内的角度值对应0度，[2.5,7.5)对应5度，依此类推。
		*/
		this.anglePerUnit=5;
		/**
		*对注册对象进行移动更新的最小间隔时间，单位为毫秒，默认值为0。<br/>
		*常用于优化与服务器同步对象状态的通讯频率。
		*/
		this.moveMinDeltaTime=0;
		/**
		*@private
		*摇杆组件的唯一子对象，其皮肤为摇杆背景，拖块为其子对象。<br/>
		*摇杆跟随模式下，此对象的位置会跟随玩家按下屏幕时的坐标点。
		*/
		this._baseSpr=null;
		/**
		*@private
		*摇杆背景皮肤路径
		*/
		this._bgSkin=null;
		/**
		*@private
		*摇杆拖块精灵
		*/
		this._knobSpr=null;
		/**
		*@private
		*摇杆拖块精灵皮肤路径
		*/
		this._knobSkin=null;
		/**
		*@private
		*摇杆类型。<br/>
		*false:摇杆跟随模式，用户按下屏幕时，摇杆更新自身位置到用户按下的位置<br/>
		*true:摇杆固定位置，用户按下屏幕时，不会自动跟随
		*/
		this._isFixed=true;
		/**
		*@private
		*当前摇杆指示的角度值。<br/>
		*X轴正方向为0，顺时针增加，取值范围[0,360)或-1(表示摇杆处于未触控状态)。
		*/
		this._angle=-1;
		/**
		*@private
		*当前摇杆指示的弧度值。<br/>
		*X轴正方向为0，顺时针增加，取值范围[0,2*PI)或-1(表示摇杆处于未触控状态)。
		*/
		this._radian=-1;
		/**
		*@private
		*是否在摇杆的激活区域内。<br/>
		*当用户触控点与摇杆基准原点的偏移量达到指定值后
		*/
		this._inActiveArea=false;
		/**
		*@private
		*用于触控精度逻辑，记录用户触控每次进行有效移动的舞台坐标
		*/
		this._moveBeginDeltaX=0;
		/**
		*@private
		*用于触控精度逻辑，记录用户触控每次进行有效移动的舞台坐标
		*/
		this._moveBeginDeltaY=0;
		/**
		*@private
		*用户在“摇杆响应区域”按下时的“触控ID”
		*/
		this._touchId=-1;
		/**
		*@private
		*摇杆组件在屏幕上的触摸响应区域
		*/
		this._touchSpr=null;
		/**
		*@private
		*用于标记对注册对象进行移动更新的最小间隔时间
		*/
		this._preTime=NaN;
		this._target=null;
		/**
		*@private
		*是否在移动设备，影响多点触控判断
		*/
		this._onMobile=false;
		/**
		*@private
		*摇杆背景纹理
		*/
		this._bgTex=null;
		/**
		*@private
		*摇杆是否启用
		*/
		this._enable=false;
		/**
		*@private
		*摇杆在无触控状态下是否自动隐藏，默认为false
		*非操控状态表示无触控状态和触控取消状态，操控状态表示触控按下和触控移动。
		*/
		this._autoHide=false;
		/**
		*@private
		*摇杆触摸区域宽度，仅在固定模式下生效
		*/
		this._touchWidth=0;
		/**
		*@private
		*摇杆触摸区域高度，仅在固定模式下生效
		*/
		this._touchHeight=0;
		/**
		*@private
		*“摇动区域中心点”相对于“摇杆背景图像中心点”在X轴上的偏移量
		*/
		this._rockAreaOfsX=0;
		/**
		*@private
		*“摇动区域中心点”相对于“摇杆背景图像中心点”在Y轴上的偏移量
		*/
		this._rockAreaOfsY=0;
		/**
		*@private
		*触控响应区域相对于摇杆中心点在X轴上的偏移量
		*/
		this._touchAreaOfsX=0;
		/**
		*@private
		*触控响应区域相对于摇杆中心点在Y轴上的偏移量
		*/
		this._touchAreaOfsY=0;
		/**
		*固定模式下摇杆的位置 0-左侧 1-右侧
		*/
		this._position=0;
		this.bgskin=null;
		this.ctrlSKin=null;
		this.keyName=null;
		this.centerPosOffCoe=0;
		Rocker.__super.call(this);
		this._touchState=Rocker.TouchNone;
	}

	__class(Rocker,'laya.maker.plugin.rocker.Rocker',_super);
	var __proto=Rocker.prototype;
	/**
	*@private
	*控制对象
	*/
	__proto.getTarget=function(){
		return this._target;
	}

	/**
	*@public
	*初始化Rocker参数
	*@param target 摇杆控制的目标接口
	*@param isFixed 摇杆是固定模式还是跟随模式。true:固定模式，摇杆固定位置，false:跟随模式，摇杆跟随用户按下时的位置
	*@param position 固定模式下摇杆的位置：0-左侧 1-右侧
	*/
	__proto.initRocker=function(target,isFixed,position){
		(isFixed===void 0)&& (isFixed=false);
		(position===void 0)&& (position=0);
		this._onMobile=Browser.onMobile;
		this._isFixed=isFixed;
		this._target=target;
		this.enable=!!this._target;
		this._position=position;
	}

	// this.on(Event.LOADED,this,onRockerLoaded);
	__proto.onRockerLoaded=function(url,texWidth,texHeight){
		this.setRockArea(texWidth / 2);
		this.setTouchArea(texWidth,texHeight);
	}

	__proto._skinLoaded=function(){
		this.setSkin(/*no*/this._skin,/*no*/this._skin.replace(".png","$bar.png"));
		this.event(/*laya.events.Event.LOADED*/"loaded");
	}

	/**
	*@private
	*被添加到父节点的事件
	*/
	__proto.onAdded=function(){
		if (!this._enable)return;
		this._touchSpr.parent || this.rockerNode.parent.addChild(this._touchSpr);
		this.updateTouchArea();
		Laya.stage.on(/*laya.events.Event.RESIZE*/"resize",this,this.updateFollowedTouchArea);
		this.autoHide=this._autoHide;
	}

	/**
	*@private
	*重置状态
	*/
	__proto.reset=function(){
		this._angle=-1;
		this._radian=-1;
		this._touchState=Rocker.TouchNone;
	}

	__proto.initialize=function(){
		this.enable=true;
	}

	/**
	*@private
	*/
	__proto.createChildren=function(){
		this.rockerNode=new RockerSprite(this);
		this.addChild(this.rockerNode);
		this._baseSpr=this.rockerNode.addChild(new Sprite());
		this._knobSpr=this._baseSpr.addChild(new Sprite());
		this._touchSpr=new Sprite();
	}

	/**
	*设置摇杆皮肤。也可以单独设置背景皮肤(setter bgSkin)和拖块皮肤(setter knobSkin)。<br/>
	*每个资源加载完成后派发Event.LOADED事件，同时返回资源路径和资源宽高。
	*@param bgSkin 背景皮肤路径
	*@param knobSkin 拖块皮肤路径
	*/
	__proto.setSkin=function(bgSkin,knobSkin){
		this.bgSkin=bgSkin;
		this.knobSkin=knobSkin;
	}

	/**
	*@private
	*/
	__proto.loadKnobTexCmpl=function(url,img){
		if (url===this._knobSkin && img && !this.rockerNode.destroyed){
			this._knobSpr.graphics.cleanByTexture(img,img.sourceWidth / 2,img.sourceHeight / 2);
			this.onRockerLoaded(url,img.sourceWidth,img.sourceHeight);
		}
	}

	/**
	*@private
	*/
	__proto.loadBgTexCmpl=function(url,img){
		if (url===this._bgSkin && img && !this.rockerNode.destroyed){
			this._bgTex=img;
			this._baseSpr.graphics.cleanByTexture(this._bgTex);
			this._baseSpr.size(img.width,img.height);
			this.onRockerLoaded(url,img.sourceWidth,img.sourceHeight);
		}
	}

	/**
	*@private
	*更新摇杆触控响应区域。
	*/
	__proto.updateTouchArea=function(){
		if (!this._touchSpr.parent || !this._enable)return;
		if (this._isFixed){
			this.updateFixedTouchArea();
		}
		else{
			this.updateFollowedTouchArea();
		}
	}

	/**
	*在跟随模式下，更新摇杆触控响应区域。<br/>
	*在跟随模式下，舞台大小会发生变化，此时如果不更新，可能会导致触控区域与预期不一致。
	*/
	__proto.updateFollowedTouchArea=function(){
		if (!this._touchSpr.parent || this._isFixed || !this._enable)return;
		var touchAreaPos=(this._touchSpr.parent).globalToLocal(Point.TEMP.setTo(0,0));
		this._touchSpr.pos(touchAreaPos.x,touchAreaPos.y);
		var sizePoi=(this._touchSpr.parent).globalToLocal(Point.TEMP.setTo(Laya.stage.width,Laya.stage.height));
		this._touchSpr.size(sizePoi.x,sizePoi.y);
	}

	/**
	*在固定模式下，更新摇杆触控响应区域。<br/>
	*在固定模式下，对摇杆进行了重定位或缩放操作，此时如果不更新，可能会导致触控区域与预期不一致。
	*/
	__proto.updateFixedTouchArea=function(){
		if (!this._touchSpr.parent || !this._isFixed || !this._enable)return;
		this._touchSpr.pos(this.rockerNode.x+(this._touchAreaOfsX-this._touchWidth / 2)*this.rockerNode.scaleX,this.rockerNode.y+(this._touchAreaOfsY-this._touchHeight / 2)*this.rockerNode.scaleY);
		this._touchSpr.size(this._touchWidth *this.rockerNode.scaleX,this._touchHeight *this.rockerNode.scaleY);
	}

	/**
	*@private
	*用户按下的触控事件
	*/
	__proto.onTouchBegin=function(e){
		this._onMobile && (this._touchId=e.touchId);
		this._touchState=1;
		this._inActiveArea=false;
		this._baseSpr.visible=true;
		var localPos;
		if (!this._isFixed){
			localPos=this.rockerNode.globalToLocal(Point.TEMP.setTo(Laya.stage.mouseX,Laya.stage.mouseY));
			this._baseSpr.pos(localPos.x,localPos.y);
			this.updatePath(this._touchState);
			return;
		}
		localPos=this._baseSpr.globalToLocal(Point.TEMP.setTo(Laya.stage.mouseX,Laya.stage.mouseY));
		var localDeltaX=localPos.x;
		var localDeltaY=localPos.y;
		this.centerPosOffCoe=Math.min(1,Math.sqrt(localDeltaX *localDeltaX+localDeltaY *localDeltaY)/ this.rockRadius);
		if (Math.abs(localDeltaX)< this.activeRadius && Math.abs(localDeltaY)< this.activeRadius){
			this.updatePath(this._touchState);
			return;
		}
		this._inActiveArea=true;
		this._moveBeginDeltaX=localDeltaX;
		this._moveBeginDeltaY=localDeltaY;
		this._radian=Math.atan2(localDeltaY,localDeltaX);
		(this._radian < 0)&& (this._radian+=Math.PI *2);
		this._angle=this._radian *57.29577951308232;
		var _sqx=localDeltaX *localDeltaX;
		var _sqy=localDeltaY *localDeltaY;
		if (_sqy+_sqx > this.rockRadius *this.rockRadius){
			var x=Math.round(Math.cos(this._radian)*this.rockRadius);
			var y=Math.round(Math.sin(this._radian)*this.rockRadius);
			this._knobSpr.pos(x,y);
		}
		else{
			this._knobSpr.pos(localDeltaX,localDeltaY);
		}
		this.updatePath(this._touchState);
	}

	/**
	*@private
	*用户触控移动事件
	*/
	__proto.onTouchMove=function(e){
		e.stopPropagation();
		if (!this._onMobile || (this._touchId===e.touchId)){
			var localPos=this._baseSpr.globalToLocal(Point.TEMP.setTo(Laya.stage.mouseX,Laya.stage.mouseY));
			var localDeltaX=localPos.x;
			var localDeltaY=localPos.y;
			if (!this._inActiveArea && Math.abs(localDeltaX)< this.activeRadius && Math.abs(localDeltaY)< this.activeRadius){
				return;
			}
			this._inActiveArea=true;
			this._touchState=2;
			if (Math.abs(localDeltaX-this._moveBeginDeltaX)< this.mouseMoveAccuracy && Math.abs(localDeltaY-this._moveBeginDeltaY)< this.mouseMoveAccuracy){
				return;
			}
			this._moveBeginDeltaX=localDeltaX;
			this._moveBeginDeltaY=localDeltaY;
			this.centerPosOffCoe=Math.min(1,Math.sqrt(localDeltaX *localDeltaX+localDeltaY *localDeltaY)/ this.rockRadius);
			this._radian=Math.atan2(localDeltaY,localDeltaX);
			(this._radian < 0)&& (this._radian+=Math.PI *2);
			this._angle=this._radian *57.29577951308232;
			var _sqx=localDeltaX *localDeltaX;
			var _sqy=localDeltaY *localDeltaY;
			if (_sqy+_sqx > this.rockRadius *this.rockRadius){
				var x=Math.floor(Math.cos(this._radian)*this.rockRadius);
				var y=Math.floor(Math.sin(this._radian)*this.rockRadius);
				this._knobSpr.pos(x,y);
			}
			else{
				this._knobSpr.pos(localDeltaX,localDeltaY);
			}
			this.updatePath(this._touchState);
		}
	}

	/**
	*@private
	*用户触控结束事件
	*/
	__proto.onTouchEnd=function(e){
		if (!this._onMobile || (this._touchId===e.touchId)){
			this._touchId=-1;
			this._touchState=3;
			this.off(/*laya.events.Event.MOUSE_MOVE*/"mousemove",this,this.onTouchMove);
			this.off(/*laya.events.Event.MOUSE_OUT*/"mouseout",this,this.onTouchCancel);
			this.off(/*laya.events.Event.MOUSE_UP*/"mouseup",this,this.onTouchEnd);
			this._knobSpr.pos(0,0);
			this._baseSpr.pos(0,0);
			this._baseSpr.visible=!this._autoHide;
			this._radian=-1;
			this._angle=-1;
			this.updatePath(this._touchState);
		}
	}

	/**
	*@private
	*更新路径
	*/
	__proto.updatePath=function(touchState){
		if (!this._target)return;
		if (2===touchState){
			if (this.moveMinDeltaTime > 0){
				var tTime=Browser.now();
				if (tTime-this._preTime < this.moveMinDeltaTime)return;
				this._preTime=tTime;
			}
			this._target.moveUpdate && this._target.moveUpdate(this.angle);
		}
		else if (1===touchState){
			this._target.moveBegin && this._target.moveBegin(this.angle);
		}
		else if (3===touchState){
			this._target.moveEnd && this._target.moveEnd();
		}
		else{
			console.log("Err: Rocker.updatePath: unknown touchState: "+touchState);
		}
	}

	/**
	*@private
	*用户触控滑出事件
	*/
	__proto.onTouchCancel=function(e){
		this.onTouchEnd(e);
	}

	/**
	*定义触控响应区域。
	*@param width 触控响应区域宽度
	*@param height 触控响应区域高度
	*@param ofsX 触控响应区域相对于摇杆中心点在X轴上的偏移量
	*@param ofsY 触控响应区域相对于摇杆中心点在Y轴上的偏移量
	*
	*/
	__proto.setTouchArea=function(width,height,ofsX,ofsY){
		(ofsX===void 0)&& (ofsX=0);
		(ofsY===void 0)&& (ofsY=0);
		if ((this._touchAreaOfsX===ofsX)&& (this._touchAreaOfsY===ofsY)&& (this._touchWidth===width)&& (this._touchHeight===height))return;
		this._touchWidth=width;
		this._touchHeight=height;
		this._touchAreaOfsX=ofsX;
		this._touchAreaOfsY=ofsY;
		this._isFixed && this._touchSpr.parent && this.updateFixedTouchArea();
	}

	/**
	*定义摇动区域。
	*@param radius 摇动区域是圆形区域，radius定义此区域的半径
	*@param ofsX “摇动区域中心点”相对于“摇杆背景图像中心点”在X轴上的偏移量
	*@param ofsY “摇动区域中心点”相对于“摇杆背景图像中心点”在Y轴上的偏移量
	*/
	__proto.setRockArea=function(radius,ofsX,ofsY){
		(ofsX===void 0)&& (ofsX=0);
		(ofsY===void 0)&& (ofsY=0);
		this.rockRadius=radius;
		if ((this._rockAreaOfsX===ofsX)&& (this._rockAreaOfsY===ofsY))return;
		this._rockAreaOfsX=ofsX;
		this._rockAreaOfsY=ofsY;
		this._bgTex && this._baseSpr.graphics.cleanByTexture(this._bgTex,-this._bgTex.width / 2-ofsX,-this._bgTex.height / 2-ofsY);
	}

	/**
	*当前摇杆指示的角度值。<br/>
	*X轴正方向为0，顺时针增加，取值范围[0,360)或-1(表示摇杆处于未触控状态)。
	*/
	__getset(0,__proto,'angle',function(){
		return this._angle==-1 ?-1 :Math.round(this._angle / this.anglePerUnit)*this.anglePerUnit;
	});

	/**
	*当前摇杆指示的弧度值。<br/>
	*X轴正方向为0，顺时针增加，取值范围[0,2*PI)或-1(表示摇杆处于未触控状态)。
	*/
	__getset(0,__proto,'radian',function(){
		return this._radian;
	});

	/**
	*@copy laya.ui.Image#skin
	*/
	__getset(0,__proto,'skin',function(){
		return /*no*/this._skin;
		},function(value){
		if (/*no*/this._skin !=value){
			/*no*/this._skin=value;
			if (/*no*/this._skin && !Loader.getRes(/*no*/this._skin)){
				Laya.loader.load(/*no*/this._skin,Handler.create(this,this._skinLoaded),null,/*laya.editorUI.Loader.IMAGE*/"image",1);
				}else{
				this._skinLoaded();
			}
		}
	});

	__getset(0,__proto,'width',function(){
		return this._width || this._baseSpr.width;
	},_super.prototype._$set_width);

	__getset(0,__proto,'height',function(){
		return this._height || this._baseSpr.height;
	},_super.prototype._$set_height);

	/**
	*触控响应区域相对于摇杆中心点在Y轴上的偏移量
	*/
	__getset(0,__proto,'touchAreaOfsY',function(){
		return this._touchAreaOfsY;
	});

	/**
	*触控响应区域宽度
	*/
	__getset(0,__proto,'touchWidth',function(){
		return this._touchWidth;
	});

	/**
	*设置拖块皮肤。<br/>
	*加载完成后派发Event.LOADED事件，同时返回资源路径和资源宽高。
	*@param knobSkin 拖块皮肤路径
	*/
	__getset(0,__proto,'knobSkin',function(){
		return this._knobSkin;
		},function(knobSkin){
		if (this._knobSkin!==knobSkin){
			this._knobSkin=knobSkin;
			if (knobSkin){
				var img=Loader.getRes(this._knobSkin);
				if (img){
					this.loadKnobTexCmpl(this._knobSkin,img);
				}
				else{
					Laya.loader.load(this._knobSkin,Handler.create(this,this.loadKnobTexCmpl,[this._knobSkin]));
				}
			}
			else{
				this._knobSpr.graphics.clear();
			}
		}
	});

	/**
	*摇杆背景皮肤。<br/>
	*加载完成后派发Event.LOADED事件，同时返回资源路径和资源宽高。
	*@param bgSkin 摇杆背景皮肤路径
	*/
	__getset(0,__proto,'bgSkin',function(){
		return this._bgSkin;
		},function(bgSkin){
		if (this._bgSkin!==bgSkin){
			this._bgSkin=bgSkin;
			if (bgSkin){
				var img=Loader.getRes(this._bgSkin);
				if (img){
					this.loadBgTexCmpl(this._bgSkin,img);
				}
				else{
					Laya.loader.load(this._bgSkin,Handler.create(this,this.loadBgTexCmpl,[this._bgSkin]));
				}
			}
			else{
				this._baseSpr.graphics.clear();
			}
		}
	});

	/**
	*获取触控状态
	*/
	__getset(0,__proto,'touchState',function(){
		return this._touchState;
	});

	/**
	*触控响应区域高度
	*/
	__getset(0,__proto,'touchHeight',function(){
		return this._touchHeight;
	});

	/**
	*触控响应区域相对于摇杆中心点在X轴上的偏移量
	*/
	__getset(0,__proto,'touchAreaOfsX',function(){
		return this._touchAreaOfsX;
	});

	/**
	*“摇动区域中心点”相对于“摇杆背景图像中心点”在X轴上的偏移量
	*/
	__getset(0,__proto,'rockAreaOfsX',function(){
		return this._rockAreaOfsX;
	});

	/**
	*“摇动区域中心点”相对于“摇杆背景图像中心点”在X轴上的偏移量
	*/
	__getset(0,__proto,'rockAreaOfsY',function(){
		return this._rockAreaOfsY;
	});

	/**
	*设置摇杆是否位置固定。摇杆有两种模式：固定模式和跟随模式。默认值为false，也就是跟随模式。<br/>
	*固定模式：玩家在摇杆触控响应区域按下时，摇杆根据玩家按下的位置相对于摇杆中心点的偏移向量更新摇杆状态。<br/>
	*固定模式下，可通过方法setTouchArea设置触控响应区域。<br/>
	*跟随模式：玩家在摇杆触控响应区域按下时，摇杆更新摇杆精灵位置到玩家按下的位置，触控仍然以摇杆中心点为原点计算偏移量。<br/>
	*跟随模式下，触控响应区域固定为左半屏，并且适配舞台大小的变化。
	*/
	__getset(0,__proto,'isFixed',function(){
		return this._isFixed;
		},function(value){
		if (this._isFixed===value)return;
		this._isFixed=value;
		this.autoHide=this._autoHide;
		this._touchSpr.parent && this.updateTouchArea();
	});

	/**
	*摇杆在无触控状态下是否自动隐藏，默认为false。<br/>
	*非操控状态表示无触控状态和触控取消状态，操控状态表示触控按下和触控移动。
	*/
	__getset(0,__proto,'autoHide',function(){
		return this._autoHide;
		},function(value){
		this._autoHide=value;
		this.isPress || (this._baseSpr.visible=!value);
	});

	/**
	*是否启用摇杆触控响应。默认值为false。<br/>
	*如果禁用，摇杆将不能响应玩家触控，但是摇杆仍然可见。
	*@param value 是否启用摇杆响应
	*/
	__getset(0,__proto,'enable',function(){
		return this._enable;
		},function(value){
		if (this._enable===value)return;
		this._enable=value;
		if (value){
			if (this.rockerNode.parent){
				this.onAdded();
			}
			else{
				this.rockerNode.on(/*laya.events.Event.ADDED*/"added",this,this.onAdded);
			}
		}
		else{
			this.off(/*laya.events.Event.RESIZE*/"resize",this,this.updateFollowedTouchArea);
			this.off(/*laya.events.Event.MOUSE_MOVE*/"mousemove",this,this.onTouchMove);
			this.off(/*laya.events.Event.MOUSE_OUT*/"mouseout",this,this.onTouchCancel);
			this.off(/*laya.events.Event.MOUSE_UP*/"mouseup",this,this.onTouchEnd);
			this._touchSpr.off(/*laya.events.Event.MOUSE_DOWN*/"mousedown",this,this.onTouchBegin);
			this._touchSpr.removeSelf();
			this.reset();
			this._baseSpr.pos(0,0);
			this._baseSpr.visible=!this._autoHide;
		}
	});

	/**
	*玩家触控是否处于按下状态。按下状态包括：TOUCH_DOWN、TOUCH_MOVE
	*@return 是否处于按下状态
	*/
	__getset(0,__proto,'isPress',function(){
		return this._touchState==1 || this._touchState==2;
	});

	Rocker.TouchNone=-1;
	Rocker.TouchDown=1;
	Rocker.TouchMove=2;
	Rocker.TouchCancel=3;
	Rocker.Factor_R2A=57.29577951308232;
	Rocker.Factor_A2R=0.017453292519943295;
	return Rocker;
})(Component)



})(window,document,Laya);

if (typeof define === 'function' && define.amd){
	define('laya.core', ['require', "exports"], function(require, exports) {
        'use strict';
        Object.defineProperty(exports, '__esModule', { value: true });
        for (var i in Laya) {
			var o = Laya[i];
            o && o.__isclass && (exports[i] = o);
        }
    });
}